home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 September / PCWorld_2007-09_cd.bin / system / ntfs / ntfsundelete.exe / {app} / sre_compile.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2007-02-06  |  11KB  |  485 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if not _sre.MAGIC == MAGIC:
  9.     raise AssertionError, 'SRE module mismatch'
  10. if _sre.CODESIZE == 2:
  11.     MAXCODE = 65535
  12. else:
  13.     MAXCODE = 0xFFFFFFFFL
  14.  
  15. def _identityfunction(x):
  16.     return x
  17.  
  18.  
  19. def _compile(code, pattern, flags):
  20.     emit = code.append
  21.     _len = len
  22.     LITERAL_CODES = {
  23.         LITERAL: 1,
  24.         NOT_LITERAL: 1 }
  25.     REPEATING_CODES = {
  26.         REPEAT: 1,
  27.         MIN_REPEAT: 1,
  28.         MAX_REPEAT: 1 }
  29.     SUCCESS_CODES = {
  30.         SUCCESS: 1,
  31.         FAILURE: 1 }
  32.     ASSERT_CODES = {
  33.         ASSERT: 1,
  34.         ASSERT_NOT: 1 }
  35.     for op, av in pattern:
  36.         if op in LITERAL_CODES:
  37.             if flags & SRE_FLAG_IGNORECASE:
  38.                 emit(OPCODES[OP_IGNORE[op]])
  39.                 emit(_sre.getlower(av, flags))
  40.             else:
  41.                 emit(OPCODES[op])
  42.                 emit(av)
  43.         flags & SRE_FLAG_IGNORECASE
  44.         None if op is IN else flags & SRE_FLAG_DOTALL
  45.         if op in REPEATING_CODES:
  46.             if flags & SRE_FLAG_TEMPLATE:
  47.                 raise error, 'internal: unsupported template operator'
  48.                 emit(OPCODES[REPEAT])
  49.                 skip = _len(code)
  50.                 emit(0)
  51.                 emit(av[0])
  52.                 emit(av[1])
  53.                 _compile(code, av[2], flags)
  54.                 emit(OPCODES[SUCCESS])
  55.                 code[skip] = _len(code) - skip
  56.             elif _simple(av) and op is not REPEAT:
  57.                 if op is MAX_REPEAT:
  58.                     emit(OPCODES[REPEAT_ONE])
  59.                 else:
  60.                     emit(OPCODES[MIN_REPEAT_ONE])
  61.                 skip = _len(code)
  62.                 emit(0)
  63.                 emit(av[0])
  64.                 emit(av[1])
  65.                 _compile(code, av[2], flags)
  66.                 emit(OPCODES[SUCCESS])
  67.                 code[skip] = _len(code) - skip
  68.             else:
  69.                 emit(OPCODES[REPEAT])
  70.                 skip = _len(code)
  71.                 emit(0)
  72.                 emit(av[0])
  73.                 emit(av[1])
  74.                 _compile(code, av[2], flags)
  75.                 code[skip] = _len(code) - skip
  76.                 if op is MAX_REPEAT:
  77.                     emit(OPCODES[MAX_UNTIL])
  78.                 else:
  79.                     emit(OPCODES[MIN_UNTIL])
  80.         op is MAX_REPEAT
  81.         if op is SUBPATTERN:
  82.             if av[0]:
  83.                 emit(OPCODES[MARK])
  84.                 emit((av[0] - 1) * 2)
  85.             
  86.             _compile(code, av[1], flags)
  87.             if av[0]:
  88.                 emit(OPCODES[MARK])
  89.                 emit((av[0] - 1) * 2 + 1)
  90.             
  91.         av[0]
  92.         if op in SUCCESS_CODES:
  93.             emit(OPCODES[op])
  94.             continue
  95.         if op in ASSERT_CODES:
  96.             emit(OPCODES[op])
  97.             skip = _len(code)
  98.             emit(0)
  99.             if av[0] >= 0:
  100.                 emit(0)
  101.             else:
  102.                 (lo, hi) = av[1].getwidth()
  103.                 if lo != hi:
  104.                     raise error, 'look-behind requires fixed-width pattern'
  105.                 
  106.                 emit(lo)
  107.             _compile(code, av[1], flags)
  108.             emit(OPCODES[SUCCESS])
  109.             code[skip] = _len(code) - skip
  110.             continue
  111.         if op is CALL:
  112.             emit(OPCODES[op])
  113.             skip = _len(code)
  114.             emit(0)
  115.             _compile(code, av, flags)
  116.             emit(OPCODES[SUCCESS])
  117.             code[skip] = _len(code) - skip
  118.             continue
  119.         if op is AT:
  120.             emit(OPCODES[op])
  121.             if flags & SRE_FLAG_MULTILINE:
  122.                 av = AT_MULTILINE.get(av, av)
  123.             
  124.             if flags & SRE_FLAG_LOCALE:
  125.                 av = AT_LOCALE.get(av, av)
  126.             elif flags & SRE_FLAG_UNICODE:
  127.                 av = AT_UNICODE.get(av, av)
  128.             
  129.             emit(ATCODES[av])
  130.             continue
  131.         if op is BRANCH:
  132.             emit(OPCODES[op])
  133.             tail = []
  134.             tailappend = tail.append
  135.             for av in av[1]:
  136.                 skip = _len(code)
  137.                 emit(0)
  138.                 _compile(code, av, flags)
  139.                 emit(OPCODES[JUMP])
  140.                 tailappend(_len(code))
  141.                 emit(0)
  142.                 code[skip] = _len(code) - skip
  143.             
  144.             emit(0)
  145.             for tail in tail:
  146.                 code[tail] = _len(code) - tail
  147.             
  148.         if op is CATEGORY:
  149.             emit(OPCODES[op])
  150.             if flags & SRE_FLAG_LOCALE:
  151.                 av = CH_LOCALE[av]
  152.             elif flags & SRE_FLAG_UNICODE:
  153.                 av = CH_UNICODE[av]
  154.             
  155.             emit(CHCODES[av])
  156.             continue
  157.         None if op is GROUPREF else av[2]
  158.         raise ValueError, ('unsupported operand type', op)
  159.     
  160.  
  161.  
  162. def _compile_charset(charset, flags, code, fixup = None):
  163.     emit = code.append
  164.     if fixup is None:
  165.         fixup = _identityfunction
  166.     
  167.     for op, av in _optimize_charset(charset, fixup):
  168.         emit(OPCODES[op])
  169.         if op is NEGATE:
  170.             continue
  171.         if op is LITERAL:
  172.             emit(fixup(av))
  173.             continue
  174.         if op is RANGE:
  175.             emit(fixup(av[0]))
  176.             emit(fixup(av[1]))
  177.             continue
  178.         if op is CHARSET:
  179.             code.extend(av)
  180.             continue
  181.         None if op is BIGCHARSET else flags & SRE_FLAG_LOCALE
  182.         raise error, 'internal: unsupported set operator'
  183.     
  184.     emit(OPCODES[FAILURE])
  185.  
  186.  
  187. def _optimize_charset(charset, fixup):
  188.     out = []
  189.     outappend = out.append
  190.     charmap = [
  191.         0] * 256
  192.     
  193.     try:
  194.         for op, av in charset:
  195.             if op is NEGATE:
  196.                 outappend((op, av))
  197.                 continue
  198.             if op is LITERAL:
  199.                 charmap[fixup(av)] = 1
  200.                 continue
  201.             if op is RANGE:
  202.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  203.                     charmap[i] = 1
  204.                 
  205.             if op is CATEGORY:
  206.                 return charset
  207.                 continue
  208.     except IndexError:
  209.         return _optimize_unicode(charset, fixup)
  210.  
  211.     i = p = n = 0
  212.     runs = []
  213.     runsappend = runs.append
  214.     for c in charmap:
  215.         if c:
  216.             if n == 0:
  217.                 p = i
  218.             
  219.             n = n + 1
  220.         elif n:
  221.             runsappend((p, n))
  222.             n = 0
  223.         
  224.         i = i + 1
  225.     
  226.     if n:
  227.         runsappend((p, n))
  228.     
  229.     if len(runs) <= 2:
  230.         for p, n in runs:
  231.             if n == 1:
  232.                 outappend((LITERAL, p))
  233.                 continue
  234.             outappend((RANGE, (p, p + n - 1)))
  235.         
  236.         if len(out) < len(charset):
  237.             return out
  238.         
  239.     else:
  240.         data = _mk_bitmap(charmap)
  241.         outappend((CHARSET, data))
  242.         return out
  243.     return charset
  244.  
  245.  
  246. def _mk_bitmap(bits):
  247.     data = []
  248.     dataappend = data.append
  249.     if _sre.CODESIZE == 2:
  250.         start = (1, 0)
  251.     else:
  252.         start = (0x1L, 0x0L)
  253.     (m, v) = start
  254.     for c in bits:
  255.         if c:
  256.             v = v + m
  257.         
  258.         m = m + m
  259.         if m > MAXCODE:
  260.             dataappend(v)
  261.             (m, v) = start
  262.             continue
  263.     
  264.     return data
  265.  
  266.  
  267. def _optimize_unicode(charset, fixup):
  268.     
  269.     try:
  270.         import array as array
  271.     except ImportError:
  272.         return charset
  273.  
  274.     charmap = [
  275.         0] * 65536
  276.     negate = 0
  277.     
  278.     try:
  279.         for op, av in charset:
  280.             if op is NEGATE:
  281.                 negate = 1
  282.                 continue
  283.             if op is LITERAL:
  284.                 charmap[fixup(av)] = 1
  285.                 continue
  286.             if op is RANGE:
  287.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  288.                     charmap[i] = 1
  289.                 
  290.             if op is CATEGORY:
  291.                 return charset
  292.                 continue
  293.     except IndexError:
  294.         return charset
  295.  
  296.     if negate:
  297.         if sys.maxunicode != 65535:
  298.             return charset
  299.         
  300.         for i in xrange(65536):
  301.             charmap[i] = not charmap[i]
  302.         
  303.     
  304.     comps = { }
  305.     mapping = [
  306.         0] * 256
  307.     block = 0
  308.     data = []
  309.     for i in xrange(256):
  310.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  311.         new = comps.setdefault(chunk, block)
  312.         mapping[i] = new
  313.         if new == block:
  314.             block = block + 1
  315.             data = data + _mk_bitmap(chunk)
  316.             continue
  317.     
  318.     header = [
  319.         block]
  320.     if _sre.CODESIZE == 2:
  321.         code = 'H'
  322.     else:
  323.         code = 'I'
  324.     mapping = array.array('b', mapping).tostring()
  325.     mapping = array.array(code, mapping)
  326.     if not mapping.itemsize == _sre.CODESIZE:
  327.         raise AssertionError
  328.     header = header + mapping.tolist()
  329.     data[0:0] = header
  330.     return [
  331.         (BIGCHARSET, data)]
  332.  
  333.  
  334. def _simple(av):
  335.     (lo, hi) = av[2].getwidth()
  336.     if lo == 0 and hi == MAXREPEAT:
  337.         raise error, 'nothing to repeat'
  338.     
  339.     return None if hi == hi else av[2][0][0] != SUBPATTERN
  340.  
  341.  
  342. def _compile_info(code, pattern, flags):
  343.     (lo, hi) = pattern.getwidth()
  344.     if lo == 0:
  345.         return None
  346.     
  347.     prefix = []
  348.     prefixappend = prefix.append
  349.     prefix_skip = 0
  350.     charset = []
  351.     charsetappend = charset.append
  352.     if not flags & SRE_FLAG_IGNORECASE:
  353.         for op, av in pattern.data:
  354.             None if op is LITERAL else op is LITERAL
  355.             break
  356.         
  357.         if not prefix and pattern.data:
  358.             (op, av) = pattern.data[0]
  359.             if op is SUBPATTERN and av[1]:
  360.                 (op, av) = av[1][0]
  361.                 if op is LITERAL:
  362.                     charsetappend((op, av))
  363.                 elif op is BRANCH:
  364.                     c = []
  365.                     cappend = c.append
  366.                     for p in av[1]:
  367.                         if not p:
  368.                             break
  369.                         
  370.                         (op, av) = p[0]
  371.                         if op is LITERAL:
  372.                             cappend((op, av))
  373.                             continue
  374.                         break
  375.                     else:
  376.                         charset = c
  377.                 
  378.             elif op is BRANCH:
  379.                 c = []
  380.                 cappend = c.append
  381.                 for p in av[1]:
  382.                     if not p:
  383.                         break
  384.                     
  385.                     (op, av) = p[0]
  386.                     if op is LITERAL:
  387.                         cappend((op, av))
  388.                         continue
  389.                     break
  390.                 else:
  391.                     charset = c
  392.             elif op is IN:
  393.                 charset = av
  394.             
  395.         
  396.     
  397.     emit = code.append
  398.     emit(OPCODES[INFO])
  399.     skip = len(code)
  400.     emit(0)
  401.     mask = 0
  402.     if prefix:
  403.         mask = SRE_INFO_PREFIX
  404.         if prefix_skip == prefix_skip:
  405.             pass
  406.         elif prefix_skip == len(pattern.data):
  407.             mask = mask + SRE_INFO_LITERAL
  408.         
  409.     elif charset:
  410.         mask = mask + SRE_INFO_CHARSET
  411.     
  412.     emit(mask)
  413.     if lo < MAXCODE:
  414.         emit(lo)
  415.     else:
  416.         emit(MAXCODE)
  417.         prefix = prefix[:MAXCODE]
  418.     if hi < MAXCODE:
  419.         emit(hi)
  420.     else:
  421.         emit(0)
  422.     if prefix:
  423.         emit(len(prefix))
  424.         emit(prefix_skip)
  425.         code.extend(prefix)
  426.         table = [
  427.             -1] + [
  428.             0] * len(prefix)
  429.         for i in xrange(len(prefix)):
  430.             table[i + 1] = table[i] + 1
  431.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  432.                 table[i + 1] = table[table[i + 1] - 1] + 1
  433.         
  434.         code.extend(table[1:])
  435.     elif charset:
  436.         _compile_charset(charset, flags, code)
  437.     
  438.     code[skip] = len(code) - skip
  439.  
  440.  
  441. try:
  442.     unicode
  443. except NameError:
  444.     STRING_TYPES = (type(''),)
  445.  
  446. STRING_TYPES = (type(''), type(unicode('')))
  447.  
  448. def isstring(obj):
  449.     for tp in STRING_TYPES:
  450.         if isinstance(obj, tp):
  451.             return 1
  452.             continue
  453.     
  454.     return 0
  455.  
  456.  
  457. def _code(p, flags):
  458.     flags = p.pattern.flags | flags
  459.     code = []
  460.     _compile_info(code, p, flags)
  461.     _compile(code, p.data, flags)
  462.     code.append(OPCODES[SUCCESS])
  463.     return code
  464.  
  465.  
  466. def compile(p, flags = 0):
  467.     if isstring(p):
  468.         import sre_parse as sre_parse
  469.         pattern = p
  470.         p = sre_parse.parse(p, flags)
  471.     else:
  472.         pattern = None
  473.     code = _code(p, flags)
  474.     if p.pattern.groups > 100:
  475.         raise AssertionError('sorry, but this version only supports 100 named groups')
  476.     
  477.     groupindex = p.pattern.groupdict
  478.     indexgroup = [
  479.         None] * p.pattern.groups
  480.     for k, i in groupindex.items():
  481.         indexgroup[i] = k
  482.     
  483.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  484.  
  485.